```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>时间轮算法：高并发定时任务处理的终极方案</title>
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #0f172a;
        }
        .hero {
            background: linear-gradient(135deg, #1e3a8a 0%, #3b82f6 100%);
        }
        .code-block {
            background-color: #1e293b;
            border-radius: 0.5rem;
            overflow: hidden;
        }
        .code-header {
            background-color: #0f172a;
            padding: 0.5rem 1rem;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }
        .diagram-container {
            background-color: white;
            border-radius: 0.75rem;
            padding: 1.5rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
        }
        .feature-card {
            transition: all 0.3s ease;
            border: 1px solid #e2e8f0;
        }
        .feature-card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
            border-color: #3b82f6;
        }
        .highlight {
            position: relative;
        }
        .highlight::after {
            content: '';
            position: absolute;
            left: 0;
            bottom: 0;
            width: 100%;
            height: 30%;
            background-color: rgba(59, 130, 246, 0.2);
            z-index: -1;
            transform: skewY(-1deg);
        }
        .drop-cap::first-letter {
            float: left;
            font-size: 3.5em;
            line-height: 0.8;
            margin-right: 0.1em;
            color: #3b82f6;
            font-weight: 700;
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero text-white py-20 px-4 sm:px-6 lg:px-8">
        <div class="max-w-5xl mx-auto">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">
                        时间轮算法：<br>
                        <span class="highlight">高并发定时任务</span>的终极方案
                    </h1>
                    <p class="text-xl text-blue-100 mb-8">
                        揭秘百万级定时任务的底层处理机制，打造高性能分布式系统的核心技术
                    </p>
                    <div class="flex space-x-4">
                        <div class="bg-white/10 backdrop-blur-sm rounded-lg p-4 flex items-center">
                            <i class="fas fa-bolt text-yellow-400 mr-2"></i>
                            <span>O(1)时间复杂度</span>
                        </div>
                        <div class="bg-white/10 backdrop-blur-sm rounded-lg p-4 flex items-center">
                            <i class="fas fa-server text-green-400 mr-2"></i>
                            <span>低系统开销</span>
                        </div>
                    </div>
                </div>
                <div class="md:w-1/2 flex justify-center">
                    <div class="relative w-full max-w-md">
                        <div class="absolute -top-6 -left-6 w-32 h-32 bg-blue-500 rounded-full mix-blend-multiply filter blur-xl opacity-70"></div>
                        <div class="absolute -bottom-8 -right-8 w-32 h-32 bg-indigo-500 rounded-full mix-blend-multiply filter blur-xl opacity-70"></div>
                        <img src="https://cdn.nlark.com/yuque/0/2025/png/21449790/1751268175974-8c3793f0-a3aa-48c5-a1ad-55d9257d30aa.png" alt="时间轮算法示意图" class="relative rounded-xl shadow-2xl border-4 border-white">
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="max-w-5xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <p class="text-lg text-slate-600 mb-8 drop-cap">
                当你的系统每秒需要处理数十万个定时任务时，普通的 setTimeout 和 setInterval 就显得捉襟见肘。想象一下，一个电商平台在双十一需要精确处理数百万个延时订单取消操作，或者一个即时通讯系统需要管理数千万用户的消息推送定时器，传统方案会让你的服务器负载飙升。
            </p>
            <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded-r-lg mb-8">
                <div class="flex">
                    <div class="flex-shrink-0">
                        <i class="fas fa-lightbulb text-blue-500 text-xl"></i>
                    </div>
                    <div class="ml-3">
                        <p class="text-sm text-blue-700">
                            时间轮算法正是为解决这类高并发定时任务而生，它如同一个精密钟表，能以极低的系统开销处理海量定时事件。今天，我将揭开这一算法的神秘面纱，带你掌握打造高性能定时系统的核心技术。
                        </p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Section 1 -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">1</span>
                定时器详解
            </h2>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-exclamation-triangle text-red-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">传统定时器的性能瓶颈</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        在Java中，我们习惯使用`Timer`类或者`ScheduledThreadPoolExecutor`来处理定时任务。然而，当面临高并发场景时，这些传统方案会遇到几个关键瓶颈：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li><strong>数据结构效率问题：</strong>传统定时器通常使用优先队列（小顶堆）存储定时任务，每次插入和删除操作的时间复杂度为O(log n)</li>
                        <li><strong>线程资源消耗：</strong>每个定时任务可能需要一个线程来执行，大量任务会导致线程资源耗尽</li>
                        <li><strong>内存占用：</strong>海量的定时任务对象会占用大量堆内存，增加GC压力</li>
                    </ul>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-bolt text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">高并发场景下的定时任务特点</h3>
                    </div>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li><strong>数量庞大：</strong>可能同时存在数十万甚至数百万个定时任务</li>
                        <li><strong>触发时间密集：</strong>在某些时间点可能有大量任务同时触发</li>
                        <li><strong>精度要求各异：</strong>有些任务对时间精度要求高（如秒级触发），有些则可接受较低精度（分钟级）</li>
                        <li><strong>重复性：</strong>许多任务是周期性执行的，而非一次性</li>
                    </ul>
                </div>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">为什么需要更高效的定时器机制</h3>
                <p class="text-slate-600 mb-6">
                    面对电商平台的订单超时取消、社交媒体的消息推送、网络服务的连接保活检测等场景，我们需要一种能够以O(1)复杂度处理定时任务的机制，这就是时间轮算法的用武之地。
                </p>
            </div>

            <div class="code-block rounded-lg mb-8">
                <div class="code-header text-white">
                    <span>传统定时器示例代码</span>
                    <span class="text-sm text-slate-300">Java</span>
                </div>
                <pre class="p-4 text-white text-sm overflow-x-auto"><code>ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);

// 创建一个延迟5秒执行的任务
scheduler.schedule(() -> {
    System.out.println("延迟任务执行");
}, 5, TimeUnit.SECONDS);

// 创建一个每3秒执行一次的周期任务
scheduler.scheduleAtFixedRate(() -> {
    System.out.println("周期任务执行");
}, 0, 3, TimeUnit.SECONDS);</code></pre>
                <div class="px-4 py-2 bg-slate-700 text-slate-300 text-sm">
                    <i class="fas fa-info-circle mr-2"></i>当任务数量达到百万级别时，这种方案的性能显著下降，系统开销急剧上升。
                </div>
            </div>
        </section>

        <!-- Section 2 -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">2</span>
                时间轮算法详解
            </h2>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-blue-600">1. 时间轮的基本概念与结构</h3>
                    <p class="text-slate-600 mb-6">
                        时间轮本质上是一个循环数组，数组的每个槽位（slot）代表一个时间间隔，每个槽位上可以挂载该时间点需要执行的任务列表。想象一个钟表，时钟指针每次只移动一格，每一格对应一组任务，时针转到哪里就执行哪里的任务，这就是时间轮的基本思想。
                    </p>
                </div>
                <div>
                    <div class="diagram-container">
                        <div class="mermaid">
                            graph TD
                                A[时间轮] --> B[时间槽1]
                                A --> C[时间槽2]
                                A --> D[...]
                                A --> E[时间槽N]
                                B --> F[任务1]
                                B --> G[任务2]
                                C --> H[任务3]
                        </div>
                    </div>
                </div>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">2. 单层时间轮实现原理</h3>
                <p class="text-slate-600 mb-6">
                    单层时间轮由以下几部分组成：时间槽数组、当前时间指针和时间跨度。工作流程如下：
                </p>
                <ol class="list-decimal pl-5 space-y-2 text-slate-600 mb-6">
                    <li>新任务根据执行时间计算应该放入哪个槽位</li>
                    <li>时间指针定时向前移动，到达某个槽位时执行该槽位中的所有任务</li>
                    <li>周期任务执行后会被重新放入对应的新槽位</li>
                </ol>
                
                <div class="code-block rounded-lg mb-6">
                    <div class="code-header text-white">
                        <span>单层时间轮实现</span>
                        <span class="text-sm text-slate-300">Java</span>
                    </div>
                    <pre class="p-4 text-white text-sm overflow-x-auto"><code>public class SimpleTimeWheel {
    // 时间轮槽数
    private final int wheelSize;
    // 每个时间槽代表的时间间隔（毫秒）
    private final long tickMs;
    // 时间轮的总时间跨度
    private final long interval;
    // 当前时间指针
    private volatile int currentTickIndex = 0;
    // 时间轮启动时间
    private final long startMs;
    // 时间槽数组，每个槽位是一个任务列表
    private final List&lt;TimeTask&gt;[] wheel;
    
    private final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
    
    public SimpleTimeWheel(int wheelSize, long tickMs) {
        this.wheelSize = wheelSize;
        this.tickMs = tickMs;
        this.interval = wheelSize * tickMs;
        this.startMs = System.currentTimeMillis();
        this.wheel = new List[wheelSize];
        
        // 初始化每个槽位的任务列表
        for (int i = 0; i &lt; wheelSize; i++) {
            wheel[i] = new ArrayList&lt;&gt;();
        }
        
        // 启动时间轮
        start();
    }
    
    // 添加任务到时间轮
    public void addTask(TimeTask task) {
        long delayMs = task.getDelayMs();
        // 延迟超过一轮的处理（简化版，实际应使用层级时间轮）
        if (delayMs &gt;= interval) {
            // 这里简化处理，实际应该放入上层时间轮
            long rounds = delayMs / interval;
            task.setRounds((int)rounds);
            delayMs = delayMs % interval;
        }
        
        // 计算槽位索引
        int ticks = (int) (delayMs / tickMs);
        int taskIndex = (currentTickIndex + ticks) % wheelSize;
        
        // 将任务添加到对应槽位
        synchronized (wheel[taskIndex]) {
            wheel[taskIndex].add(task);
        }
    }
    
    // 启动时间轮
    private void start() {
        executor.scheduleAtFixedRate(() -&gt; {
            int currentIndex = currentTickIndex;
            
            // 处理当前时间槽的任务
            synchronized (wheel[currentIndex]) {
                Iterator&lt;TimeTask&gt; iterator = wheel[currentIndex].iterator();
                while (iterator.hasNext()) {
                    TimeTask task = iterator.next();
                    
                    // 检查任务是否需要多轮后执行
                    if (task.getRounds() &gt; 0) {
                        task.setRounds(task.getRounds() - 1);
                        continue;
                    }
                    
                    // 执行任务
                    executor.execute(task::execute);
                    iterator.remove();
                    
                    // 如果是周期任务，重新放入时间轮
                    if (task.isPeriodic()) {
                        addTask(task);
                    }
                }
            }
            
            // 时间指针前进一步
            currentTickIndex = (currentTickIndex + 1) % wheelSize;
            
        }, 0, tickMs, TimeUnit.MILLISECONDS);
    }
}</code></pre>
                </div>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">3. 层级时间轮设计思路</h3>
                <p class="text-slate-600 mb-6">
                    单层时间轮的一个明显缺点是处理不了跨度太大的定时任务。解决方案是使用层级时间轮，类似于时钟的时、分、秒指针：
                </p>
                <ul class="list-disc pl-5 space-y-2 text-slate-600 mb-6">
                    <li><strong>第一层时间轮：</strong>精度高（如毫秒级），轮次少</li>
                    <li><strong>第二层时间轮：</强>精度中等（如秒级），轮次适中</li>
                    <li><strong>第三层时间轮：</strong>精度低（如分钟级），轮次多</li>
                </ul>
                <p class="text-slate-600">
                    当任务的延迟时间超过第一层时间轮的总跨度时，会被放入第二层；如果仍然超过，则放入更高层。高层的时间槽到期后，任务会被"降级"到低层时间轮继续等待执行。
                </p>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">4. 时间轮与哈希轮算法的关系</h3>
                <p class="text-slate-600">
                    哈希轮算法（HashedWheelTimer）是时间轮算法的一种优化实现，它使用哈希表来提高查找效率，并采用了更高效的内存管理方式。在Netty等高性能框架中广泛应用。
                </p>
            </div>
        </section>

        <!-- Section 3 -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">3</span>
                时间轮在开源项目中的应用
            </h2>
            
            <div class="grid md:grid-cols-3 gap-6 mb-8">
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 p-2 rounded-lg mr-4">
                            <i class="fab fa-java text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">Netty HashedWheelTimer 源码剖析</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        Netty的HashedWheelTimer是时间轮算法的经典实现，它通过以下优化提升了性能：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li>使用了数组链表结构，降低了锁竞争</li>
                        <li>采用延迟初始化策略，减少资源浪费</li>
                        <li>任务执行与时间轮推进分离，提高响应速度</li>
                    </ul>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-project-diagram text-green-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">Kafka 延迟操作中的时间轮应用</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        Kafka使用了分层时间轮来处理延迟操作，如延迟生产、消费位移提交等。其时间轮实现有以下特点：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li>采用了层级时间轮设计，支持不同精度的延迟操作</li>
                        <li>使用了高效的任务重排策略，减少时间轮层级间的任务传递开销</li>
                        <li>结合了Kafka的事件驱动模型，实现了高性能的定时任务处理</li>
                    </ul>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-database text-red-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">Redis 过期键处理机制解析</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        Redis虽然没有直接使用时间轮算法，但其过期键处理机制采用了类似的思想：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li>将过期键存储在单独的字典中</li>
                        <li>采用主动过期和惰性过期相结合的策略</li>
                        <li>周期性随机采样过期键进行清理，避免集中处理导致的性能抖动</li>
                    </ul>
                </div>
            </div>

            <div class="code-block rounded-lg">
                <div class="code-header text-white">
                    <span>Netty HashedWheelTimer 核心实现</span>
                    <span class="text-sm text-slate-300">Java</span>
                </div>
                <pre class="p-4 text-white text-sm overflow-x-auto"><code>public class HashedWheelTs {
    // 时间轮槽
    private final HashedWheelBucket[] wheel;
    // 工作线程
    private final Worker worker = new Worker();
    private final Thread workerThread;
    
    // 时间轮配置
    private final long tickDuration;
    private final int mask;
    
    // 启动时间
    private volatile long startTime;
    
    // 等待执行的任务队列
    private final Queue&lt;HashedWheelTsTimeout&gt; waitingTasks = new LinkedBlockingQueue&lt;&gt;();
    
    public HashedWheelTs(int ticksPerWheel, long tickDuration) {
        // 确保ticksPerWheel是2的幂，便于使用位运算计算槽位
        int normalizedTicksPerWheel = normalizeTicksPerWheel(ticksPerWheel);
        
        // 创建时间轮数组
        wheel = new HashedWheelBucket[normalizedTicksPerWheel];
        for (int i = 0; i &lt; wheel.length; i++) {
            wheel[i] = new HashedWheelBucket();
        }
        
        this.mask = wheel.length - 1;
        this.tickDuration = tickDuration;
        
        // 创建但不启动工作线程
        workerThread = new Thread(worker, "HashedWheelTs-Worker");
    }
    
    // 启动时间轮
    public void start() {
        if (workerThread.getState() == Thread.State.NEW) {
            workerThread.start();
        }
    }
    
    // 添加定时任务
    public Timeout newTimeout(TimerTask task, long delay, TimeUnit unit) {
        HashedWheelTsTimeout timeout = new HashedWheelTsTimeout(task, 
                                                           System.nanoTime() + unit.toNanos(delay));
        waitingTasks.add(timeout);
        return timeout;
    }
    
    // 工作线程，负责推进时间轮
    private class Worker implements Runnable {
        private long tick = 0;
        
        @Override
        public void run() {
            startTime = System.nanoTime();
            
            while (true) {
                // 计算需要等待的时间
                long deadline = waitForNextTick();
                
                // 处理新添加的任务
                transferTasksToBuckets();
                
                // 获取当前槽位并处理任务
                int idx = (int) (tick & mask);
                HashedWheelBucket bucket = wheel[idx];
                bucket.expireTasks(deadline);
                
                // 时间前进一步
                tick++;
            }
        }
        
        private void transferTasksToBuckets() {
            // 将等待队列中的任务转移到对应的时间槽
            HashedWheelTsTimeout task;
            while ((task = waitingTasks.poll()) != null) {
                // 计算任务应该在哪个槽位
                long calculated = task.deadline / tickDuration;
                long remainingRounds = (calculated - tick) / wheel.length;
                
                task.remainingRounds = remainingRounds;
                
                // 计算槽位索引
                int stopIndex = (int) (calculated & mask);
                HashedWheelBucket bucket = wheel[stopIndex];
                bucket.addTimeout(task);
            }
        }
        
        private long waitForNextTick() {
            // 计算下一个tick的时间点
            long deadline = startTime + (tick + 1) * tickDuration;
            long currentTime = System.nanoTime();
            
            // 如果还没到时间，就等待
            if (currentTime &lt; deadline) {
                try {
                    Thread.sleep((deadline - currentTime) / 1000000);
                } catch (InterruptedException ignored) {
                }
            }
            
            return deadline;
        }
    }
    
    // 时间槽，存储定时任务
    private static class HashedWheelBucket {
        // 任务链表头
        private HashedWheelTsTimeout head;
        
        // 添加任务
        public void addTimeout(HashedWheelTsTimeout timeout) {
            timeout.next = head;
            head = timeout;
        }
        
        // 执行到期任务
        public void expireTasks(long deadline) {
            HashedWheelTsTimeout prev = null;
            HashedWheelTsTimeout current = head;
            
            while (current != null) {
                if (current.remainingRounds &lt;= 0) {
                    // 到期任务，从链表中移除
                    if (prev == null) {
                        head = current.next;
                    } else {
                        prev.next = current.next;
                    }
                    
                    // 执行任务
                    try {
                        current.task.run(current);
                    } catch (Throwable t) {
                        // 异常处理
                    }
                    
                    current = prev == null ? head : prev.next;
                } else {
                    // 未到期，减少轮次
                    current.remainingRounds--;
                    prev = current;
                    current = current.next;
                }
            }
        }
    }
}</code></pre>
            </div>
        </section>

        <!-- Section 4 -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">4</span>
                自己动手实现一个时间轮定时器
            </h2>
            
            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">1. 核心数据结构设计</h3>
                <p class="text-slate-600 mb-6">
                    以下是一个完整的层级时间轮实现：
                </p>
                <div class="code-block rounded-lg mb-6">
                    <div class="code-header text-white">
                        <span>层级时间轮实现</span>
                        <span class="text-sm text-slate-300">Java</span>
                    </div>
                    <pre class="p-4 text-white text-sm overflow-x-auto"><code>public class HierarchicalTimeWheel {
    // 第一层时间轮
    private final TimeWheel timeWheel;
    // 执行器
    private final ScheduledExecutorService executor;
    // 任务执行线程池
    private final ExecutorService taskExecutor;
    
    public HierarchicalTimeWheel(int ticksPerWheel, long tickDurationMs, int workerThreads) {
        this.timeWheel = new TimeWheel(ticksPerWheel, tickDurationMs, System.currentTimeMillis());
        this.executor = Executors.newSingleThreadScheduledExecutor();
        this.taskExecutor = Executors.newFixedThreadPool(workerThreads);
        
        // 启动时间轮
        start();
    }
    
    private void start() {
        executor.scheduleAtFixedRate(() -&gt; {
            // 推进时间轮
            timeWheel.advanceClock();
        }, timeWheel.getTickDuration(), timeWheel.getTickDuration(), TimeUnit.MILLISECONDS);
    }
    
    // 添加任务
    public void addTask(Runnable task, long delayMs) {
        TsTask tsTask = new TsTask(task, delayMs);
        timeWheel.addTask(tsTask);
    }
    
    // 时间轮实现
    private class TimeWheel {
        private final long tickDuration;
        private final int wheelSize;
        private final List&lt;TsTask&gt;[] buckets;
        private long currentTime;
        
        // 上层时间轮，用于处理超出当前时间轮范围的任务
        private TimeWheel overflowWheel;
        
        @SuppressWarnings("unchecked")
        public TimeWheel(int wheelSize, long tickDuration, long startTime) {
            this.wheelSize = wheelSize;
            this.tickDuration = tickDuration;
            this.currentTime = startTime - (startTime % tickDuration);
            this.buckets = new List[wheelSize];
            
            for (int i = 0; i &lt; wheelSize; i++) {
                buckets[i] = new ArrayList&lt;&gt;();
            }
        }
        
        public long getTickDuration() {
            return tickDuration;
        }
        
        // 添加任务到时间轮
        public void addTask(TsTask task) {
            long expiration = task.getExpiration();
            
            // 计算任务延迟
            long delayMs = expiration - currentTime;
            
            // 已过期任务立即执行
            if (delayMs &lt; 0) {
                taskExecutor.execute(task.getTask());
                return;
            }
            
            // 计算任务应该放在哪一层时间轮
            if (delayMs &lt; tickDuration * wheelSize) {
                // 计算应该放在当前层时间轮的哪个槽位
                int ticks = (int) (delayMs / tickDuration);
                int index = (int) (((currentTime / tickDuration) + ticks) % wheelSize);
                
                synchronized (buckets[index]) {
                    buckets[index].add(task);
                }
            } else {
                // 需要放入上层时间轮
                if (overflowWheel == null) {
                    overflowWheel = new TimeWheel(wheelSize, tickDuration * wheelSize, currentTime);
                }
                overflowWheel.addTask(task);
            }
        }
        
        // 推进时间轮
        public void advanceClock() {
            currentTime += tickDuration;
            checkAndExecuteTasks();
            
            // 如果有上层时间轮，也推进上层时间轮
            if (overflowWheel != null) {
                overflowWheel.advanceClock();
            }
        }
        
        // 检查并执行到期任务
        private void checkAndExecuteTasks() {
            int index = (int) ((currentTime / tickDuration) % wheelSize);
            List&lt;TsTask&gt; tasksToExecute = new ArrayList&lt;&gt;();
            
            // 获取当前槽位的任务
            synchronized (buckets[index]) {
                if (!buckets[index].isEmpty()) {
                    tasksToExecute.addAll(buckets[index]);
                    buckets[index].clear();
                }
            }
            
            // 执行任务
            for (TsTask task : tasksToExecute) {
                if (task.getExpiration() &lt;= currentTime) {
                    taskExecutor.execute(task.getTask());
                } else {
                    // 重新加入时间轮
                    addTask(task);
                }
            }
        }
    }
    
    // 时间任务封装
    private static class TsTask {
        private final Runnable task;
        private final long expiration;
        
        public TsTask(Runnable task, long delayMs) {
            this.task = task;
            this.expiration = System.currentTimeMillis() + delayMs;
        }
        
        public Runnable getTask() {
            return task;
        }
        
        public long getExpiration() {
            return expiration;
        }
    }
}</code></pre>
                </div>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">2. 时间轮调度器实现</h3>
                <p class="text-slate-600 mb-6">
                    上述代码中的`HierarchicalTimeWheel`类已经实现了基本的时间轮调度器功能，它提供了以下核心特性：
                </p>
                <ul class="list-disc pl-5 space-y-2 text-slate-600 mb-6">
                    <li>层级时间轮结构，支持不同时间粒度的定时任务</li>
                    <li>任务执行与时间轮推进分离，使用独立的线程池执行任务</li>
                    <li>O(1)复杂度的任务调度，适合高并发场景</li>
                </ul>
                
                <div class="code-block rounded-lg">
                    <div class="code-header text-white">
                        <span>使用示例</span>
                        <span class="text-sm text-slate-300">Java</span>
                    </div>
                    <pre class="p-4 text-white text-sm overflow-x-auto"><code>public class TimeWheelDemo {
    public static void main(String[] args) {
        // 创建一个有20个槽位，每个槽位代表100ms的时间轮，使用5个工作线程
        HierarchicalTimeWheel timeWheel = new HierarchicalTimeWheel(20, 100, 5);
        
        // 添加一个延迟500ms的任务
        timeWheel.addTask(() -&gt; {
            System.out.println("任务1执行，延迟500ms");
        }, 500);
        
        // 添加一个延迟5秒的任务
        timeWheel.addTask(() -&gt; {
            System.out.println("任务2执行，延迟5000ms");
        }, 5000);
        
        // 保持主线程运行
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}</code></pre>
                </div>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">3. 处理精度与性能权衡</h3>
                <p class="text-slate-600">
                    在设计时间轮时，需要权衡精度和性能：
                </p>
                <ul class="list-disc pl-5 space-y-2 text-slate-600">
                    <li><strong>槽位数量：</strong>槽位越多，精度越高，但内存占用也越大</li>
                    <li><strong>时间粒度：</strong>时间粒度越小，精度越高，但CPU使用率也越高</li>
                    <li><strong>层级深度：</strong>层级越多，支持的时间跨度越大，但实现复杂度增加</li>
                </ul>
            </div>
        </section>

        <!-- Section 5 -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">5</span>
                时间轮实践
            </h2>
            
            <div class="grid md:grid-cols-3 gap-6 mb-8">
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-yellow-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-balance-scale text-yellow-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">槽数量与时间精度的权衡</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        选择合适的槽数量和时间粒度是时间轮设计的关键。一般原则如下：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li>对于毫秒级精度的短期任务，可以设置第一层时间轮为100~1000个槽位，时间粒度为1ms</li>
                        <li>对于秒级精度的中期任务，可以设置第二层时间轮为60个槽位，时间粒度为1s</li>
                        <li>对于分钟级精度的长期任务，可以设置第三层时间轮为60个槽位，时间粒度为1min</li>
                    </ul>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-indigo-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-lock text-indigo-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">减少锁竞争的策略</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        在高并发场景下，锁竞争是影响性能的主要因素，可采取以下策略减少锁竞争：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li><strong>分段锁：</strong>为不同的时间槽使用不同的锁，减少锁的粒度</li>
                        <li><strong>无锁队列：</strong>使用CAS操作的无锁队列存储任务</li>
                        <li><strong>任务批处理：</strong>一次性获取多个任务进行批量处理</li>
                    </ul>
                </div>
                
                <div class="feature-card bg-white p-6 rounded-xl">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 p-2 rounded-lg mr-4">
                            <i class="fas fa-memory text-green-500 text-xl"></i>
                        </div>
                        <h3 class="text-xl font-semibold">内存使用优化技巧</h3>
                    </div>
                    <p class="text-slate-600 mb-4">
                        时间轮处理海量任务时，内存使用是一个关键问题：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li><strong>对象池化：</strong>重用任务对象，避免频繁创建和销毁</li>
                        <li><strong>懒加载：</strong>层级时间轮采用懒加载策略，需要时再创建上层时间轮</li>
                        <li><strong>任务聚合：</strong>将多个相似任务聚合为一个，减少对象数量</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Section 6 -->
        <section class="mb-16">
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">6</span>
                分布式系统中的时间轮应用
            </h2>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-blue-600">1. 分布式定时任务调度设计</h3>
                    <p class="text-slate-600 mb-6">
                        在分布式环境中，可以结合时间轮和一致性哈希算法设计高效的任务调度系统：
                    </p>
                    <div class="code-block rounded-lg mb-6">
                        <div class="code-header text-white">
                            <span>分布式时间轮设计</span>
                            <span class="text-sm text-slate-300">Java</span>
                        </div>
                        <pre class="p-4 text-white text-sm overflow-x-auto"><code>public class DistributedTimeWheel {
    private final HierarchicalTimeWheel timeWheel;
    private final ConsistentHash&lt;String&gt; consistentHash;
    private final String nodeId;
    
    public DistributedTimeWheel(String nodeId, List&lt;String&gt; allNodes) {
        this.nodeId = nodeId;
        this.timeWheel = new HierarchicalTimeWheel(20, 100, 10);
        this.consistentHash = new ConsistentHash&lt;&gt;(3, allNodes);
    }
    
    // 添加分布式任务
    public void addTask(String taskId, Runnable task, long delayMs) {
        // 根据任务ID判断是否应该由当前节点处理
        String targetNode = consistentHash.getNode(taskId);
        
        if (targetNode.equals(nodeId)) {
            // 当前节点负责处理此任务
            timeWheel.addTask(task, delayMs);
        } else {
            // 其他节点负责，忽略或转发
        }
    }
}</code></pre>
                    </div>
                </div>
                
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-blue-600">2. 高可用时间轮集群方案</h3>
                    <p class="text-slate-600 mb-6">
                        为了保证时间轮的高可用，可以采用主备模式或分片模式：
                    </p>
                    <div class="diagram-container">
                        <div class="mermaid">
                            graph TD
                                A[客户端] --> B[时间轮集群]
                                B --> C[主节点]
                                B --> D[备节点1]
                                B --> E[备节点2]
                                C -->|任务同步| D
                                C -->|任务同步| E
                        </div>
                    </div>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600 mt-6">
                        <li><strong>主备模式：</strong>一个主节点运行时间轮，备节点实时同步任务状态，主节点故障时接管</li>
                        <li><strong>分片模式：</strong>根据任务ID将任务分配到不同节点，每个节点负责一部分任务</li>
                    </ul>
                </div>
            </div>
        </section>

        <!-- Section 7 -->
        <section>
            <h2 class="text-3xl font-bold mb-6 flex items-center">
                <span class="bg-blue-500 w-8 h-8 rounded-full flex items-center justify-center text-white mr-3">7</span>
                时间轮的局限性与替代方案
            </h2>
            
            <div class="grid md:grid-cols-2 gap-8 mb-8">
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-blue-600">1. 时间轮不适用的场景分析</h3>
                    <p class="text-slate-600 mb-6">
                        时间轮并非万能，在以下场景可能不是最佳选择：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li><strong>精确到微秒级的定时要求：</strong>时间轮通常以毫秒为粒度，更高精度会导致性能下降</li>
                        <li><strong>任务执行时间远长于调度时间：</strong>此时瓶颈在于任务执行而非调度</li>
                        <li><strong>任务数量极少但延迟极大：</strong>时间轮的空间效率在此类场景下不占优势</li>
                    </ul>
                </div>
                
                <div>
                    <h3 class="text-2xl font-semibold mb-4 text-blue-600">2. GC压力与内存消耗问题</h3>
                    <p class="text-slate-600 mb-6">
                        时间轮在处理海量任务时，可能面临以下内存问题：
                    </p>
                    <ul class="list-disc pl-5 space-y-2 text-slate-600">
                        <li>大量任务对象占用堆内存，增加GC压力</li>
                        <li>时间槽数组占用连续内存空间</li>
                        <li>任务对象生命周期管理不当导致内存泄漏</li>
                    </ul>
                </div>
            </div>

            <div class="mb-8">
                <h3 class="text-2xl font-semibold mb-4 text-blue-600">3. 其他高效定时器算法对比</h3>
                <p class="text-slate-600 mb-6">
                    除了时间轮，还有其他高效的定时器算法值得考虑：
                </p>
                <div class="overflow-x-auto">
                    <table class="min-w-full bg-white rounded-lg overflow-hidden">
                        <thead class="bg-gray-100">
                            <tr>
                                <th class="py-3 px-4 text-left font-semibold text-slate-700">算法</th>
                                <th class="py-3 px-4 text-left font-semibold text-slate-700">时间复杂度</th>
                                <th class="py-3 px-4 text-left font-semibold text-slate-700">适用场景</th>
                                <th class="py-3 px-4 text-left font-semibold text-slate-700">代表实现</th>
                            </tr>
                        </thead>
                        <tbody class="divide-y divide-gray-200">
                            <tr>
                                <td class="py-3 px-4 text-slate-600">时间轮</td>
                                <td class="py-3 px-4 text-slate-600">O(1)</td>
                                <td class="py-3 px-4 text-slate-600">高频短延迟任务</td>
                                <td class="py-3 px-4 text-slate-600">Netty, Kafka</td>
                            </tr>
                            <tr>
                                <td class="py-3 px-4 text-slate-600">层次时间堆</td>
                                <td class="py-3 px-4 text-slate-600">O(log n)</td>
                                <td class="py-3 px-4 text-slate-600">任务数量波动大</td>
                                <td class="py-3 px-4 text-slate-600">Linux内核</td>
                            </tr>
                            <tr>
                                <td class="py-3 px-4 text-slate-600">分桶延迟队列</td>
                                <td class="py-3 px-4 text-slate-600">O(1)</td>
                                <td class="py-3 px-4 text-slate-600">批量处理任务</td>
                                <td class="py-3 px-4 text-slate-600">Redis</td>
                            </tr>
                        </tbody>
                    </table>
                </div>
            </div>
        </section>
    </main>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```